home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume26 / unproto / part01 next >
Encoding:
Text File  |  1991-12-07  |  53.0 KB  |  2,111 lines
  1. Newsgroups: comp.sources.misc
  2. From: wietse@wzv.win.tue.nl (Wietse Venema)
  3. Subject:  v26i094:  unproto - compile ANSI C with old C compiler, Part01/02
  4. Message-ID: <csm-v26i094=unproto.083344@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 69685c0673793ce6c539657a3d1de2ab
  6. Date: Sun, 1 Dec 1991 14:35:08 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: wietse@wzv.win.tue.nl (Wietse Venema)
  10. Posting-number: Volume 26, Issue 94
  11. Archive-name: unproto/part01
  12. Environment: SYSV2, SunOS
  13. Supersedes: unproto: Volume 23, Issue 12-13
  14.  
  15. This is a filter that sits in between the C preprocessor and the next C
  16. compiler stage, and that on the fly rewrites ANSI C to old C. Its
  17. primary application is to compile ANSI C software in UNIX environments
  18. that do not (yet) have an ANSI C compiler and that cannot run GCC
  19. because of technical or political problems.
  20.  
  21. Problems solved with this release:
  22.  
  23. Minor: the program was originally intended for the compilation of
  24. already tested ANSI C source, so that diagnostics from the native C
  25. compiler would be sufficient. The present release produces better
  26. diagnostics, so that it can also be used for program development.
  27.  
  28. Major: the template Makefile suggested that all #pragma directives be
  29. filtered out. This turns out to be a bad idea because some non-ANSI
  30. compilers (SunOS) rely on #pragmas to correctly handle the unusual flow
  31. control caused by vfork(2), setjmp(3) etcetera. A warning to this
  32. effect has been added to the Makefile.
  33.  
  34. No changes were made to the actual filter logic; output should be
  35. identical to that of the previous release.
  36.  
  37. #! /bin/sh
  38. # This is a shell archive.  Remove anything before this line, then unpack
  39. # it by saving it into a file and typing "sh file".  To overwrite existing
  40. # files, type "sh file -c".  You can also feed this as standard input via
  41. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  42. # will see the following message at the end:
  43. #        "End of archive 1 (of 2)."
  44. # Contents:  Makefile README cpp.sh error.c error.h example.c
  45. #   example.out stdarg.h symbol.c symbol.h tok_class.c tok_io.c
  46. #   tok_pool.c token.h unproto.1 varargs.c vstring.c vstring.h
  47. # Wrapped by wietse@wzv on Sun Dec  1 12:43:04 1991
  48. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  49. if test -f Makefile -a "${1}" != "-c" ; then 
  50.   echo shar: Will not over-write existing file \"Makefile\"
  51. else
  52. echo shar: Extracting \"Makefile\" \(2877 characters\)
  53. sed "s/^X//" >Makefile <<'END_OF_Makefile'
  54. X# @(#) Makefile 1.3 91/12/01 12:37:57
  55. X
  56. X## BEGIN CONFIGURATION STUFF
  57. X
  58. X# For maximal flexibility, the "/lib/cpp | unproto" pipeline can be
  59. X# packaged as an executable shell script (see the provided "cpp.sh" script)
  60. X# that should be installed as "/whatever/cpp". This script should then be
  61. X# specified to the C compiler as a non-default preprocessor.
  62. X#
  63. X# PROG    = unproto
  64. X# PIPE    = 
  65. X
  66. X# For maximal performance, the overhead of shell script inpretation can
  67. X# be eliminated by having the unprototyper program itself open the pipe
  68. X# to the preprocessor.  In that case, define the PIPE_THROUGH_CPP macro
  69. X# as the path name of the default C preprocessor (usually "/lib/cpp"),
  70. X# install the unprototyper as "/whatever/cpp" and specify that to the C
  71. X# compiler as a non-default preprocessor.
  72. X# 
  73. XPROG    = cpp
  74. XPIPE    = -DPIPE_THROUGH_CPP=\"/lib/cpp\"
  75. X
  76. X# Some compilers complain about some #directives. The following is only a 
  77. X# partial solution, because the directives are still seen by /lib/cpp.
  78. X# Be careful with filtering out #pragma, because some non-ANSI compilers
  79. X# (SunOS) rely on its use.
  80. X#
  81. X# SKIP    = -DIGNORE_DIRECTIVES=\"pragma\",\"foo\",\"bar\"
  82. X#
  83. XSKIP    =
  84. X
  85. X# If you need support for functions that implement ANSI-style variable
  86. X# length argument lists, edit the stdarg.h file provided with this
  87. X# package so that it contains the proper definitions for your machine.
  88. X
  89. X## END CONFIGURATION STUFF
  90. X
  91. XSHELL    = /bin/sh
  92. X
  93. XCFILES    = tok_io.c tok_class.c tok_pool.c unproto.c vstring.c symbol.c error.c
  94. XHFILES    = error.h token.h vstring.h symbol.h
  95. XSCRIPTS    = cpp.sh
  96. XSAMPLES    = stdarg.h varargs.c example.c example.out 
  97. XSOURCES    = README Makefile $(CFILES) $(HFILES) $(SCRIPTS) $(SAMPLES)
  98. XFILES    = $(SOURCES) unproto.1
  99. XOBJECTS    = tok_io.o tok_class.o tok_pool.o unproto.o vstring.o symbol.o error.o
  100. X
  101. XCFLAGS    = -O $(PIPE) $(SKIP)
  102. X#CFLAGS    = -O -pg -Dstatic= $(PIPE) $(SKIP)
  103. X#CFLAGS    = -g $(PIPE) $(SKIP) -DDEBUG
  104. X
  105. X$(PROG): $(OBJECTS)
  106. X    cc $(CFLAGS) -o $@ $(OBJECTS) $(MALLOC)
  107. X
  108. X# For linting, enable all bells and whistles.
  109. X
  110. Xlint:
  111. X    lint -DPIPE_THROUGH_CPP=\"foo\" -DIGNORE_DIRECTIVES=\"foo\",\"bar\" \
  112. X    $(CFILES)
  113. X
  114. X# Testing requires that the program is compiled with -DDEBUG
  115. X
  116. Xtest:    $(PROG) example.c example.out
  117. X    ./cpp example.c >example.tmp
  118. X    @echo the following diff command should produce no output
  119. X    diff -b example.out example.tmp
  120. X    rm -f example.tmp
  121. X
  122. Xshar:    $(FILES)
  123. X    @shar $(FILES)
  124. X
  125. Xarchive:
  126. X    $(ARCHIVE) $(SOURCES)
  127. X
  128. Xclean:
  129. X    rm -f *.o core cpp unproto mon.out varargs.o varargs example.tmp
  130. X
  131. Xerror.o : error.c token.h error.h Makefile
  132. Xsymbol.o : symbol.c token.h symbol.h Makefile
  133. Xtok_class.o : tok_class.c error.h vstring.h token.h symbol.h Makefile
  134. Xtok_io.o : tok_io.c token.h vstring.h error.h Makefile
  135. Xtok_pool.o : tok_pool.c token.h vstring.h Makefile
  136. Xunproto.o : unproto.c vstring.h stdarg.h token.h error.h symbol.h Makefile
  137. Xvarargs.o : varargs.c stdarg.h Makefile
  138. Xvstring.o : vstring.c vstring.h Makefile
  139. END_OF_Makefile
  140. if test 2877 -ne `wc -c <Makefile`; then
  141.     echo shar: \"Makefile\" unpacked with wrong size!
  142. fi
  143. # end of overwriting check
  144. fi
  145. if test -f README -a "${1}" != "-c" ; then 
  146.   echo shar: Will not over-write existing file \"README\"
  147. else
  148. echo shar: Extracting \"README\" \(5616 characters\)
  149. sed "s/^X//" >README <<'END_OF_README'
  150. X@(#) README 1.3 91/12/01 12:37:55
  151. X
  152. Xunproto - ANSI C to old C converter
  153. X
  154. XPurpose:
  155. X
  156. XThis is a filter that sits in between the C preprocessor and the next C
  157. Xcompiler stage, and that on the fly rewrites ANSI C to old C. Its
  158. Xprimary application is to compile ANSI C software in UNIX environments
  159. Xthat do not (yet) have an ANSI C compiler and that cannot run GCC
  160. Xbecause of technical or political problems.
  161. X
  162. XThe filter leaves old-style C alone, and de-ANSI-fies function
  163. Xheadings, function pointer type declarations (and casts), function type
  164. Xdeclarations, and combinations thereof. Many freely-distributable
  165. Xunprotoizers have problems with the latter because they are based on a
  166. Xnon-recursive algorithm or even make assumptions about code layout.
  167. X
  168. XThe unprototyper has support for systems that require special tricks
  169. Xfor variadic functions (fortunately, many don't). A sample `stdarg.h'
  170. Xfile is provided with support for sparc, mc68k, 80x86, vax and others.
  171. X
  172. XThe program has been tested on a Sun SLC running SunOS 4.1.1 and on a
  173. X80286 PC clone running Microport's version of System V Release 2. It
  174. Xruns at about the same speed as /lib/cpp, so it should have negigible
  175. Ximpact on compilation times.
  176. X
  177. XProblems solved with this release:
  178. X
  179. XMinor: the program was originally intended for the compilation of
  180. Xalready tested ANSI C source, so that diagnostics from the native C
  181. Xcompiler would be sufficient. The present release produces better
  182. Xdiagnostics, so that it can also be used for program development.
  183. X
  184. XMajor: the template Makefile suggested that all #pragma directives be
  185. Xfiltered out. This turns out to be a bad idea because some non-ANSI
  186. Xcompilers (SunOS) rely on #pragmas to correctly handle the unusual flow
  187. Xcontrol caused by vfork(2), setjmp(3) etcetera. A warning to this
  188. Xeffect has been added to the Makefile.
  189. X
  190. XNo changes were made to the actual filter logic; output should be
  191. Xidentical to that of the previous release.
  192. X
  193. XRestrictions:
  194. X
  195. XOther ANSI-isms are just passed on without modification, such as
  196. Xtrigraphs, token pasting (##), #pragmas, stringizing (#text) and
  197. Xstring concatenation ("string1" "string2").
  198. X
  199. XThe unprototyper does not understand declarations of (object). The
  200. Xresult (the object disappears) will be a syntax error so this should
  201. Xnot go by unnoticed.
  202. X
  203. XSome C programmers rely on ANSI-style prototypes for the automatic type
  204. Xconversion of function arguments.  The unprototyper, however, does not
  205. Xgenerate casts. The lack of automatic conversion between integral
  206. Xand/or pointer argument types should not be a problem in environments
  207. Xwhere sizeof(int) == sizeof(long) == sizeof(pointer).  A more serious
  208. Xproblem is the lack of automatic type conversions beteen integral and
  209. Xfloating-point function argument types.  Let lint(1) be your friend.
  210. X
  211. XOperation:
  212. X
  213. XThis package implements an non-default C preprocessor (the output from
  214. Xthe default C preprocessor being piped through the unprototyper).  How
  215. Xone tells the C compiler to use an non-default preprocessor program is
  216. Xsomewhat compiler-dependent:
  217. X
  218. X    SunOS 4.x:  cc -Qpath directory_with_non-default_cpp ...
  219. X
  220. X    SysV Rel2:  cc -Bdirectory_with_non-default_cpp/ -tp ...
  221. X
  222. XYour C compiler manual should provide the necessary information.
  223. X
  224. XOn some systems the lint(1) command is just a shell script, and writing
  225. Xa version that uses the unprototyper should not be too hard. With SunOS
  226. X4.x, /usr/bin/lint is not a shell script, but it does accept the same
  227. Xsyntax as the cc(1) command for the specification of a non-default
  228. Xcompiler pass. 
  229. X
  230. XYou may have to do some research on the lint command provided with your
  231. Xown machine.
  232. X
  233. XConfiguration:
  234. X
  235. XCheck the contents of the `stdarg.h' file provided with this package.
  236. XThis file serves a dual purpose. It should be included by C source file
  237. Xthat implements ANSI-style variadic functions. It is also used to
  238. Xconfigure the `unproto' program so that it emits the proper magic for
  239. Xthe `...' construct.
  240. X
  241. XThe `stdarg.h' file contains definitions for the sparc architecture and
  242. Xfor architectures that pass arguments via the stack (usually OK for
  243. X80*86, mc68k and vax C compilers).  Risc processors often need special
  244. Xtricks.  These are usually found in the file `/usr/include/varargs.h'.
  245. X
  246. XThe file `varargs.c' provided with this package can be used to verify
  247. Xthat the `stdarg.h' file has been set up correctly.
  248. X
  249. XFor maximal flexibility, you can use the `cpp' shell script provided
  250. Xwith this package to set up the pipe between the default C preprocessor
  251. Xand the unprototyper command. The script assumes that the unprototyper
  252. Xbinary is called `unproto'. See the cpp.sh script and the Makefile for
  253. Xdetails.
  254. X
  255. XThe overhead of shell-script interpretation can be avoided by having
  256. Xthe unprototyper itself open the pipe to the C preprocessor.  In this
  257. Xcase, the `unproto.c' source file should be compiled with the
  258. X`PIPE_THROUGH_CPP' macro defined as the pathname of the C preprocessor
  259. X(usually `/lib/cpp'), and the unprototyper binary should be called
  260. X`cpp'.  See the Makefile for details.
  261. X
  262. XInstallation:
  263. X
  264. XInstall the `stdarg.h' include file and the `unproto.1' manual page in
  265. Xsuitable places.
  266. X
  267. XIf you use the `cpp' shell script to pipe the preprocessor output
  268. Xthrough the unprototyper program, install the `unproto' binary in a
  269. Xplace where the `cpp' shell script can find it, and install the `cpp'
  270. Xshell script in a suitable place.
  271. X
  272. XIf the unprototyper itself opens the pipe to the C preprocessor (i.e.
  273. Xthe unprototyper was built with the `PIPE_THROUGH_CPP' macro defined),
  274. Xinstall the `cpp' unprototyper binary in a suitable place.
  275. X
  276. X    Wietse Venema
  277. X    wietse@wzv.win.tue.nl
  278. X    Eindhoven University of Technology
  279. X    The Netherlands
  280. END_OF_README
  281. if test 5616 -ne `wc -c <README`; then
  282.     echo shar: \"README\" unpacked with wrong size!
  283. fi
  284. # end of overwriting check
  285. fi
  286. if test -f cpp.sh -a "${1}" != "-c" ; then 
  287.   echo shar: Will not over-write existing file \"cpp.sh\"
  288. else
  289. echo shar: Extracting \"cpp.sh\" \(311 characters\)
  290. sed "s/^X//" >cpp.sh <<'END_OF_cpp.sh'
  291. X#!/bin/sh
  292. X
  293. X# @(#) cpp.sh 1.2 91/09/22 21:21:43
  294. X
  295. X# Unprototypeing preprocessor for non-ANSI C compilers. Define __STDC__
  296. X# if you have enough courage. You will have to modify this script if
  297. X# your cc(1) command specifies output file names to the preprocessor.
  298. X
  299. Xexec /lib/cpp "$@" -Dconst= -Dvolatile= | unproto 
  300. END_OF_cpp.sh
  301. if test 311 -ne `wc -c <cpp.sh`; then
  302.     echo shar: \"cpp.sh\" unpacked with wrong size!
  303. fi
  304. # end of overwriting check
  305. fi
  306. if test -f error.c -a "${1}" != "-c" ; then 
  307.   echo shar: Will not over-write existing file \"error.c\"
  308. else
  309. echo shar: Extracting \"error.c\" \(1675 characters\)
  310. sed "s/^X//" >error.c <<'END_OF_error.c'
  311. X/*++
  312. X/* NAME
  313. X/*    error 3
  314. X/* SUMMARY
  315. X/*    diagnostics
  316. X/* PACKAGE
  317. X/*    unproto
  318. X/* SYNOPSIS
  319. X/*    #include "error.h"
  320. X/*
  321. X/*    void error(quit, text)
  322. X/*    int quit;
  323. X/*    char *text;
  324. X/*
  325. X/*    void error_where(quit, path, line, text)
  326. X/*    int quit;
  327. X/*    char *path;
  328. X/*    int line;
  329. X/*    char *text;
  330. X/* DESCRIPTION
  331. X/*    The routines in this file print a diagnostic (text) and optionally
  332. X/*    terminate the program (quit != 0) with exit status "quit".
  333. X/*
  334. X/*    error() provides a default context, i.e. the source-file
  335. X/*    coordinate of the last read token.
  336. X/*
  337. X/*    error_where() allows the caller to explicitly specify context: path
  338. X/*    is a source-file name, and line is a line number.
  339. X/*
  340. X/*    context is ignored if the line number is zero or if the path
  341. X/*    is an empty string.
  342. X/* AUTHOR(S)
  343. X/*    Wietse Venema
  344. X/*    Eindhoven University of Technology
  345. X/*    Department of Mathematics and Computer Science
  346. X/*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  347. X/* LAST MODIFICATION
  348. X/*    91/11/30 21:10:35
  349. X/* VERSION/RELEASE
  350. X/*    1.1
  351. X/*--*/
  352. X
  353. Xstatic char error_sccsid[] = "@(#) error.c 1.1 91/11/30 21:10:35";
  354. X
  355. X/* C library */
  356. X
  357. X#include <stdio.h>
  358. X
  359. Xvoid exit();
  360. X
  361. X/* Application-specific stuff */
  362. X
  363. X#include "token.h"
  364. X#include "error.h"
  365. X
  366. X/* error - report problem (implicit context) and optionally quit */
  367. X
  368. Xvoid    error(quit, text)
  369. Xint     quit;
  370. Xchar   *text;
  371. X{
  372. X    error_where(quit, curr_path, curr_line, text);
  373. X}
  374. X
  375. X/* error_where - report problem (explicit context) and optionally quit */
  376. X
  377. Xvoid    error_where(quit, path, line, text)
  378. Xint     quit;
  379. Xchar   *path;
  380. Xint     line;
  381. Xchar   *text;
  382. X{
  383. X    if (line && path[0])
  384. X    fprintf(stderr, "%s, line %d: ", path, line);
  385. X    fprintf(stderr, "%s\n", text);
  386. X    if (quit)
  387. X    exit(quit);
  388. X}
  389. END_OF_error.c
  390. if test 1675 -ne `wc -c <error.c`; then
  391.     echo shar: \"error.c\" unpacked with wrong size!
  392. fi
  393. # end of overwriting check
  394. fi
  395. if test -f error.h -a "${1}" != "-c" ; then 
  396.   echo shar: Will not over-write existing file \"error.h\"
  397. else
  398. echo shar: Extracting \"error.h\" \(144 characters\)
  399. sed "s/^X//" >error.h <<'END_OF_error.h'
  400. X/* @(#) error.h 1.1 91/11/30 21:10:36 */
  401. X
  402. Xextern void error();            /* default context */
  403. Xextern void error_where();        /* user-specified context */
  404. END_OF_error.h
  405. if test 144 -ne `wc -c <error.h`; then
  406.     echo shar: \"error.h\" unpacked with wrong size!
  407. fi
  408. # end of overwriting check
  409. fi
  410. if test -f example.c -a "${1}" != "-c" ; then 
  411.   echo shar: Will not over-write existing file \"example.c\"
  412. else
  413. echo shar: Extracting \"example.c\" \(2062 characters\)
  414. sed "s/^X//" >example.c <<'END_OF_example.c'
  415. X /*
  416. X  * @(#) example.c 1.2 91/09/22 21:21:45
  417. X  * 
  418. X  * Examples of things that can be done with the unproto package
  419. X  */
  420. X
  421. X /*
  422. X  * New-style argument list with structured argument, one field being pointer
  423. X  * to function returning pointer to function with function-pointer argument
  424. X  */
  425. X
  426. Xx(struct {
  427. X    struct {
  428. X    int (*(*foo) (int (*arg1) (double))) (float arg2);
  429. X    } foo;
  430. X} baz) {
  431. X    return (0);
  432. X}
  433. X
  434. X /*
  435. X  * Old-style argument list with new-style argument type, declaration
  436. X  * embedded within block. Plus a couple assignments with function calls that
  437. X  * look like casts.
  438. X  */
  439. X
  440. Xfoo(bar)
  441. Xint     (*(*bar) (float)) (int);
  442. X{
  443. X    int     (*baz) (int) = (int (*) (int)) 0,
  444. X        y = (y * (*baz) (y)),
  445. X        *(*z) (int) = (int *(*) (int)) 0;
  446. X
  447. X    struct { int (*foo)(int); } *(*s)(int) = 
  448. X    (struct { int (*foo)(int); } *(*)(int)) 0;
  449. X
  450. X    {
  451. X    y = (y * (*baz) (y));
  452. X    }
  453. X    {
  454. X    z = (int *(*) (int)) 0;
  455. X    }
  456. X    {
  457. X    s = (struct { int (*foo)(int); } *(*)(int)) 0;
  458. X    }
  459. X
  460. X    return (0);
  461. X}
  462. X
  463. X/* Multiple declarations in one statement */
  464. X
  465. Xtest1()
  466. X{
  467. X    int foo2,*(*(*bar)(int))(float),*baz(double);
  468. X}
  469. X
  470. X/* Discriminate declarations from executable statements */
  471. X
  472. Xtest2(char *y)
  473. X{
  474. X    int foo = 5,atoi(char *);
  475. X
  476. X    foo = 5,atoi(y);
  477. X}
  478. X
  479. X/* Declarations without explicit type */
  480. X
  481. Xtest3,test4(int);
  482. X
  483. Xtest5(int y)
  484. X{
  485. X    {
  486. X        test3;
  487. X    }
  488. X    {
  489. X        test4(y);
  490. X    }
  491. X}
  492. X
  493. Xtest6[1],test7(int);
  494. X
  495. Xtest7(int x)
  496. X{
  497. X    {
  498. X        test6[1];
  499. X    }
  500. X    {
  501. X        test7(x);
  502. X    }
  503. X}
  504. X
  505. X/* Checking a complicated cast */
  506. X
  507. Xstruct {
  508. X    struct {
  509. X    int (*f)(int), o;
  510. X    } bar;
  511. X} (*baz2)(int) = (struct { struct { int (*f)(int), o; } bar; } (*)(int)) 0;
  512. X
  513. X/* Distinguish things with the same shape but with different meaning */
  514. X
  515. Xtest8(x)
  516. X{
  517. X    {
  518. X    struct {
  519. X        int     foo;
  520. X    } bar(int);
  521. X    }
  522. X    {
  523. X    do {
  524. X        int     foo;
  525. X    } while (x);
  526. X    }
  527. X}
  528. X
  529. X/* Do not think foo(*bar) is a function pointer declaration */
  530. X
  531. Xtest9(char *bar)
  532. X{
  533. X    foo(*bar);
  534. X}
  535. X
  536. X/* another couple of special-cased words. */
  537. X
  538. Xtest10(int x)
  539. X{
  540. X    {
  541. X    int test10(int);
  542. X    do  test10(x);
  543. X    while (x);
  544. X    }
  545. X    {
  546. X    return test10(x);
  547. X    }
  548. X}
  549. X
  550. Xtest11(int *x)
  551. X{
  552. X    while (*x)
  553. X        (putchar(*x++));
  554. X}
  555. END_OF_example.c
  556. if test 2062 -ne `wc -c <example.c`; then
  557.     echo shar: \"example.c\" unpacked with wrong size!
  558. fi
  559. # end of overwriting check
  560. fi
  561. if test -f example.out -a "${1}" != "-c" ; then 
  562.   echo shar: Will not over-write existing file \"example.out\"
  563. else
  564. echo shar: Extracting \"example.out\" \(1994 characters\)
  565. sed "s/^X//" >example.out <<'END_OF_example.out'
  566. X# 1 "example.c" 
  567. X 
  568. X
  569. X
  570. X
  571. X
  572. X
  573. X 
  574. X
  575. X
  576. X
  577. X
  578. Xx
  579. X
  580. X
  581. X
  582. X(baz)
  583. X# 16 "example.c"
  584. Xstruct {    struct {    int (*(*foo)())();    } foo;} baz;
  585. X# 16 "example.c"
  586. X{/*1*/
  587. X    /* end dcls */return (0);
  588. X}/*1*/
  589. X
  590. X 
  591. X
  592. X
  593. X
  594. X
  595. X
  596. Xfoo
  597. X(bar)int     (*(*bar)())();
  598. X{/*1*/
  599. X    int     (*baz)() = (int (*)()) 0,
  600. X        y = (y * (*baz)(y)),
  601. X        *(*z)() = (int *(*)()) 0;
  602. X
  603. X    struct {/*2*/ int (*foo)(); }/*2*/ *(*s)() = 
  604. X    (struct { int (*foo)(); } *(*)()) 0;
  605. X
  606. X    /* end dcls */{/*2*/
  607. X    y /* end dcls */= (y * (*baz)(y));
  608. X    }/*2*/
  609. X    {/*2*/
  610. X    z /* end dcls */= (int *(*)()) 0;
  611. X    }/*2*/
  612. X    {/*2*/
  613. X    s /* end dcls */= (struct { int (*foo)(); } *(*)()) 0;
  614. X    }/*2*/
  615. X
  616. X    return (0);
  617. X}/*1*/
  618. X
  619. X
  620. X
  621. Xtest1
  622. X()
  623. X# 52 "example.c"
  624. X{/*1*/
  625. X    int foo2,*(*(*bar)())(),*baz();
  626. X}/*1*/
  627. X
  628. X
  629. X
  630. Xtest2
  631. X(y)
  632. X# 59 "example.c"
  633. Xchar *y;
  634. X# 59 "example.c"
  635. X{/*1*/
  636. X    int foo = 5,atoi();
  637. X
  638. X    foo /* end dcls */= 5,atoi(y);
  639. X}/*1*/
  640. X
  641. X
  642. X
  643. Xtest3,test4();
  644. X
  645. Xtest5
  646. X(y)
  647. X# 70 "example.c"
  648. Xint y;
  649. X# 70 "example.c"
  650. X{/*1*/
  651. X    /* end dcls */{/*2*/
  652. X        test3/* end dcls */;
  653. X    }/*2*/
  654. X    {/*2*/
  655. X        test4/* end dcls */(y);
  656. X    }/*2*/
  657. X}/*1*/
  658. X
  659. Xtest6[1],test7();
  660. X
  661. Xtest7
  662. X(x)
  663. X# 82 "example.c"
  664. Xint x;
  665. X# 82 "example.c"
  666. X{/*1*/
  667. X    /* end dcls */{/*2*/
  668. X        test6/* end dcls */[1];
  669. X    }/*2*/
  670. X    {/*2*/
  671. X        test7/* end dcls */(x);
  672. X    }/*2*/
  673. X}/*1*/
  674. X
  675. X
  676. X
  677. Xstruct {/*1*/
  678. X    struct {/*2*/
  679. X    int (*f)(), o;
  680. X    }/*2*/ bar;
  681. X}/*1*/ (*baz2)() = (struct { struct { int (*f)(), o; } bar; } (*)()) 0;
  682. X
  683. X
  684. X
  685. Xtest8
  686. X(x)
  687. X# 102 "example.c"
  688. X{/*1*/
  689. X    /* end dcls */{/*2*/
  690. X    struct {/*3*/
  691. X        int     foo;
  692. X    }/*3*/ bar();
  693. X    }/*2*/
  694. X    {/*2*/
  695. X    /* end dcls */do {/*3*/
  696. X        int     foo;
  697. X    }/*3*/ while (x);
  698. X    }/*2*/
  699. X}/*1*/
  700. X
  701. X
  702. X
  703. Xtest9
  704. X(bar)
  705. X# 118 "example.c"
  706. Xchar *bar;
  707. X# 118 "example.c"
  708. X{/*1*/
  709. X    foo/* end dcls */(*bar);
  710. X}/*1*/
  711. X
  712. X
  713. X
  714. Xtest10
  715. X(x)
  716. X# 125 "example.c"
  717. Xint x;
  718. X# 125 "example.c"
  719. X{/*1*/
  720. X    /* end dcls */{/*2*/
  721. X    int test10();
  722. X    /* end dcls */do  test10(x);
  723. X    while (x);
  724. X    }/*2*/
  725. X    {/*2*/
  726. X    /* end dcls */return test10(x);
  727. X    }/*2*/
  728. X}/*1*/
  729. X
  730. Xtest11
  731. X(x)
  732. X# 137 "example.c"
  733. Xint *x;
  734. X# 137 "example.c"
  735. X{/*1*/
  736. X    /* end dcls */while (*x)
  737. X        (putchar(*x++));
  738. X}/*1*/
  739. END_OF_example.out
  740. if test 1994 -ne `wc -c <example.out`; then
  741.     echo shar: \"example.out\" unpacked with wrong size!
  742. fi
  743. # end of overwriting check
  744. fi
  745. if test -f stdarg.h -a "${1}" != "-c" ; then 
  746.   echo shar: Will not over-write existing file \"stdarg.h\"
  747. else
  748. echo shar: Extracting \"stdarg.h\" \(1413 characters\)
  749. sed "s/^X//" >stdarg.h <<'END_OF_stdarg.h'
  750. X /*
  751. X  * @(#) stdarg.h 1.2 91/11/30 21:10:39
  752. X  * 
  753. X  * Sample stdarg.h file for use with the unproto filter.
  754. X  * 
  755. X  * This file serves two purposes.
  756. X  * 
  757. X  * 1 - As an include file for use with ANSI-style C source that implements
  758. X  * variadic functions.
  759. X  * 
  760. X  * 2 - To configure the unproto filter itself. If the _VA_ALIST_ macro is
  761. X  * defined, its value will appear in the place of the "..." in argument
  762. X  * lists of variadic function *definitions* (not declarations).
  763. X  * 
  764. X  * Compilers that pass arguments via the stack can use the default code at the
  765. X  * end of this file (this usually applies for the VAX, MC68k and 80*86
  766. X  * architectures).
  767. X  * 
  768. X  * RISC-based systems often need special tricks. An example of the latter is
  769. X  * given for the SPARC architecture. Read your /usr/include/varargs.h for
  770. X  * more information.
  771. X  * 
  772. X  * You can use the varargs.c program provided with the unproto package to
  773. X  * verify that the stdarg.h file has been set up correctly.
  774. X  */
  775. X
  776. X#ifdef sparc
  777. X#  define _VA_ALIST_        "__builtin_va_alist"
  778. X   typedef char *va_list;
  779. X#  define va_start(ap, p)    (ap = (char *) &__builtin_va_alist)
  780. X#  define va_arg(ap, type)    ((type *) __builtin_va_arg_incr((type *) ap))[0]
  781. X#  define va_end(ap)
  782. X#else /* vax, mc68k, 80*86 */
  783. X   typedef char *va_list;
  784. X#  define va_start(ap, p)    (ap = (char *) (&(p)+1))
  785. X#  define va_arg(ap, type)    ((type *) (ap += sizeof(type)))[-1]
  786. X#  define va_end(ap)
  787. X#endif
  788. END_OF_stdarg.h
  789. if test 1413 -ne `wc -c <stdarg.h`; then
  790.     echo shar: \"stdarg.h\" unpacked with wrong size!
  791. fi
  792. # end of overwriting check
  793. fi
  794. if test -f symbol.c -a "${1}" != "-c" ; then 
  795.   echo shar: Will not over-write existing file \"symbol.c\"
  796. else
  797. echo shar: Extracting \"symbol.c\" \(3522 characters\)
  798. sed "s/^X//" >symbol.c <<'END_OF_symbol.c'
  799. X/*++
  800. X/* NAME
  801. X/*    symbol 3
  802. X/* SUMMARY
  803. X/*    rudimentary symbol table package
  804. X/* SYNOPSIS
  805. X/*    #include "symbol.h"
  806. X/*
  807. X/*    void sym_init()
  808. X/*
  809. X/*    void sym_enter(name, type)
  810. X/*    char *name;
  811. X/*    int type;
  812. X/*
  813. X/*    struct symbol *sym_find(name)
  814. X/*    char *name;
  815. X/* DESCRIPTION
  816. X/*    This is a rudimentary symbol-table package, just enough to
  817. X/*    keep track of a couple of C keywords.
  818. X/*
  819. X/*    sym_init() primes the table with C keywords. At present, most of
  820. X/*    the keywords that have to do with types are left out.
  821. X/*    We need a different strategy to detect type definitions because
  822. X/*    we do not keep track of typedef names.
  823. X/*
  824. X/*    sym_enter() adds an entry to the symbol table.
  825. X/*
  826. X/*    sym_find() locates a symbol table entry (it returns 0 if
  827. X/*    it is not found).
  828. X/* AUTHOR(S)
  829. X/*    Wietse Venema
  830. X/*    Eindhoven University of Technology
  831. X/*    Department of Mathematics and Computer Science
  832. X/*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  833. X/* LAST MODIFICATION
  834. X/*    91/11/30 21:10:33
  835. X/* VERSION/RELEASE
  836. X/*    1.2
  837. X/*--*/
  838. X
  839. Xstatic char symbol_sccsid[] = "@(#) symbol.c 1.2 91/11/30 21:10:33";
  840. X
  841. X/* C library */
  842. X
  843. Xextern char *strcpy();
  844. Xextern char *malloc();
  845. X
  846. X/* Application-specific stuff */
  847. X
  848. X#include "error.h"
  849. X#include "token.h"
  850. X#include "symbol.h"
  851. X
  852. X#define    SYM_TABSIZE    20
  853. X
  854. Xstatic struct symbol *sym_tab[SYM_TABSIZE] = {0,};
  855. X
  856. X/* More string stuff. Maybe it should go to an #include file. */
  857. X
  858. X#define    STREQ(x,y)    (*(x) == *(y) && strcmp((x),(y)) == 0)
  859. X
  860. X/* hash - hash a string; original author: P. J. Weinberger at Bell Labs. */
  861. X
  862. Xstatic unsigned hash(s, size)
  863. Xregister char *s;
  864. Xunsigned size;
  865. X{
  866. X    register unsigned long h = 0;
  867. X    register unsigned long g;
  868. X
  869. X    /*
  870. X     * For a performance comparison with the hash function presented in K&R,
  871. X     * first edition, see the "Dragon" book by Aho, Sethi and Ullman.
  872. X     */
  873. X
  874. X    while (*s) {
  875. X    h = (h << 4) + *s++;
  876. X    if (g = (h & 0xf0000000)) {
  877. X        h ^= (g >> 24);
  878. X        h ^= g;
  879. X    }
  880. X    }
  881. X    return (h % size);
  882. X}
  883. X
  884. X/* sym_enter - enter symbol into table */
  885. X
  886. Xvoid    sym_enter(name, type)
  887. Xchar   *name;
  888. Xint     type;
  889. X{
  890. X    struct symbol *s;
  891. X    int     where;
  892. X
  893. X    if ((s = (struct symbol *) malloc(sizeof(*s))) == 0
  894. X    || (s->name = malloc(strlen(name) + 1)) == 0)
  895. X    error(1, "out of memory");
  896. X    (void) strcpy(s->name, name);
  897. X    s->type = type;
  898. X
  899. X    where = hash(name, SYM_TABSIZE);
  900. X    s->next = sym_tab[where];
  901. X    sym_tab[where] = s;
  902. X}
  903. X
  904. X/* sym_find - locate symbol definition */
  905. X
  906. Xstruct symbol *sym_find(name)
  907. Xregister char *name;
  908. X{
  909. X    register struct symbol *s;
  910. X
  911. X    /*
  912. X     * This function is called for almost every "word" token, so it better be
  913. X     * fast.
  914. X     */
  915. X
  916. X    for (s = sym_tab[hash(name, SYM_TABSIZE)]; s; s = s->next)
  917. X    if (STREQ(name, s->name))
  918. X        return (s);
  919. X    return (0);
  920. X}
  921. X
  922. X /*
  923. X  * Initialization data for symbol table. We do not enter keywords for types.
  924. X  * We use a different strategy to detect type declarations because we do not
  925. X  * keep track of typedef names.
  926. X  */
  927. X
  928. Xstruct sym {
  929. X    char   *name;
  930. X    int     tokno;
  931. X};
  932. X
  933. Xstatic struct sym syms[] = {
  934. X    "if", TOK_CONTROL,
  935. X    "else", TOK_CONTROL,
  936. X    "while", TOK_CONTROL,
  937. X    "do", TOK_CONTROL,
  938. X    "switch", TOK_CONTROL,
  939. X    "case", TOK_CONTROL,
  940. X    "default", TOK_CONTROL,
  941. X    "return", TOK_CONTROL,
  942. X    "continue", TOK_CONTROL,
  943. X    "break", TOK_CONTROL,
  944. X    "goto", TOK_CONTROL,
  945. X    "struct", TOK_COMPOSITE,
  946. X    "union", TOK_COMPOSITE,
  947. X    0,
  948. X};
  949. X
  950. X/* sym_init - enter known keywords into symbol table */
  951. X
  952. Xvoid    sym_init()
  953. X{
  954. X    register struct sym *p;
  955. X
  956. X    for (p = syms; p->name; p++)
  957. X    sym_enter(p->name, p->tokno);
  958. X}
  959. X
  960. END_OF_symbol.c
  961. if test 3522 -ne `wc -c <symbol.c`; then
  962.     echo shar: \"symbol.c\" unpacked with wrong size!
  963. fi
  964. # end of overwriting check
  965. fi
  966. if test -f symbol.h -a "${1}" != "-c" ; then 
  967.   echo shar: Will not over-write existing file \"symbol.h\"
  968. else
  969. echo shar: Extracting \"symbol.h\" \(318 characters\)
  970. sed "s/^X//" >symbol.h <<'END_OF_symbol.h'
  971. X/* @(#) symbol.h 1.1 91/09/22 21:21:42 */
  972. X
  973. Xstruct symbol {
  974. X    char   *name;            /* symbol name */
  975. X    int     type;            /* symbol type */
  976. X    struct symbol *next;
  977. X};
  978. X
  979. Xextern void sym_enter();        /* add symbol to table */
  980. Xextern struct symbol *sym_find();    /* locate symbol */
  981. Xextern void sym_init();            /* prime the table */
  982. END_OF_symbol.h
  983. if test 318 -ne `wc -c <symbol.h`; then
  984.     echo shar: \"symbol.h\" unpacked with wrong size!
  985. fi
  986. # end of overwriting check
  987. fi
  988. if test -f tok_class.c -a "${1}" != "-c" ; then 
  989.   echo shar: Will not over-write existing file \"tok_class.c\"
  990. else
  991. echo shar: Extracting \"tok_class.c\" \(4091 characters\)
  992. sed "s/^X//" >tok_class.c <<'END_OF_tok_class.c'
  993. X/*++
  994. X/* NAME
  995. X/*    tok_class 3
  996. X/* SUMMARY
  997. X/*    token classification
  998. X/* PACKAGE
  999. X/*    unproto
  1000. X/* SYNOPSIS
  1001. X/*    #include "token.h"
  1002. X/*
  1003. X/*    struct token *tok_class(skip)
  1004. X/*    int skip;
  1005. X/* DESCRIPTION
  1006. X/*    tok_class() collects a single and composite tokens, and
  1007. X/*    recognizes keywords.
  1008. X/*    At present, the only composite tokens are ()-delimited,
  1009. X/*    comma-separated lists.
  1010. X/*
  1011. X/*    The skip argument has the same meaning as with the tok_get()
  1012. X/*    function.
  1013. X/* DIAGNOSTICS
  1014. X/*    The code complains if input terminates in the middle of a list.
  1015. X/* BUGS
  1016. X/*    Does not preserve white space at the beginning of a list element
  1017. X/*    or after the end of a list.
  1018. X/* AUTHOR(S)
  1019. X/*    Wietse Venema
  1020. X/*    Eindhoven University of Technology
  1021. X/*    Department of Mathematics and Computer Science
  1022. X/*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  1023. X/* LAST MODIFICATION
  1024. X/*    91/11/30 21:10:28
  1025. X/* VERSION/RELEASE
  1026. X/*    1.3
  1027. X/*--*/
  1028. X
  1029. Xstatic char class_sccsid[] = "@(#) tok_class.c 1.3 91/11/30 21:10:28";
  1030. X
  1031. X/* C library */
  1032. X
  1033. X#include <stdio.h>
  1034. X
  1035. Xextern char *strcpy();
  1036. X
  1037. X/* Application-specific stuff */
  1038. X
  1039. X#include "error.h"
  1040. X#include "vstring.h"
  1041. X#include "token.h"
  1042. X#include "symbol.h"
  1043. X
  1044. Xstatic struct token *tok_list();
  1045. Xstatic void tok_list_struct();
  1046. Xstatic void tok_list_append();
  1047. X
  1048. X/* tok_space_append - append trailing space except after list */
  1049. X
  1050. X#define    tok_space_append(list,t) { \
  1051. X                    if (list == 0     /* leading space*/ \
  1052. X                    || list->tokno == TOK_LIST) \
  1053. X                    tok_free(t); \
  1054. X                    else \
  1055. X                    tok_list_append(list, t); \
  1056. X                }
  1057. X
  1058. X/* tok_class - discriminate single tokens, keywords, and composite tokens */
  1059. X
  1060. Xstruct token *tok_class(skip)
  1061. Xint     skip;
  1062. X{
  1063. X    register struct token *t;
  1064. X    register struct symbol *s;
  1065. X
  1066. X    if (t = tok_get(skip)) {
  1067. X    switch (t->tokno) {
  1068. X    case '(':                /* beginning of list */
  1069. X        t = tok_list(t);
  1070. X        break;
  1071. X    case TOK_WORD:                /* look up keyword */
  1072. X        if (s = sym_find(t->vstr->str))
  1073. X        t->tokno = s->type;
  1074. X        break;
  1075. X    }
  1076. X    }
  1077. X    return (t);
  1078. X}
  1079. X
  1080. X/* tok_list - collect ()-delimited, comma-separated list of tokens */
  1081. X
  1082. Xstatic struct token *tok_list(t)
  1083. Xstruct token *t;
  1084. X{
  1085. X    register struct token *list = tok_alloc();
  1086. X    char    filename[BUFSIZ];
  1087. X    int     lineno;
  1088. X
  1089. X    /* Save context of '(' for diagnostics. */
  1090. X
  1091. X    strcpy(filename, curr_path);
  1092. X    lineno = curr_line;
  1093. X
  1094. X    list->tokno = TOK_LIST;
  1095. X    list->head = list->tail = t;
  1096. X#ifdef DEBUG
  1097. X    strcpy(list->vstr->str, "LIST");
  1098. X#endif
  1099. X
  1100. X    for (;;) {
  1101. X    if ((t = tok_get(DO_WSPACE)) == 0) {    /* skip blanks */
  1102. X        error_where(0, filename, lineno, "unmatched '('");
  1103. X        return (list);            /* do not waste any data */
  1104. X    }
  1105. X    switch (t->tokno) {
  1106. X    case ')':                /* end of list */
  1107. X        tok_free(t);
  1108. X        return (list);
  1109. X    case '{':                /* struct/union type */
  1110. X        tok_list_struct(list->tail, t);
  1111. X        break;
  1112. X    case TOK_WSPACE:            /* preserve trailing blanks */
  1113. X        tok_space_append(list->tail->tail, t);    /* except after list */
  1114. X        break;
  1115. X    case '\n':                /* preserve line count */
  1116. X        tok_flush(t);
  1117. X        break;
  1118. X    case ',':                /* list separator */
  1119. X        tok_list_append(list, t);
  1120. X        break;
  1121. X    case '(':                /* beginning of list */
  1122. X        tok_list_append(list->tail, tok_list(t));
  1123. X        break;
  1124. X    default:                /* ordinary token */
  1125. X        tok_list_append(list->tail, t);
  1126. X        break;
  1127. X    }
  1128. X    }
  1129. X}
  1130. X
  1131. X/* tok_list_struct - collect structured type info within list */
  1132. X
  1133. Xstatic void tok_list_struct(list, t)
  1134. Xregister struct token *list;
  1135. Xregister struct token *t;
  1136. X{
  1137. X    tok_list_append(list, t);
  1138. X
  1139. X    while (t = tok_class(DO_WSPACE)) {
  1140. X    switch (t->tokno) {
  1141. X    case '\n':                /* preserve line count */
  1142. X        tok_flush(t);
  1143. X        break;
  1144. X    case TOK_WSPACE:            /* preserve trailing blanks */
  1145. X        tok_space_append(list->tail, t);    /* except after list */
  1146. X        break;
  1147. X    case '{':                /* recurse */
  1148. X        tok_list_struct(list, t);
  1149. X        break;
  1150. X    case '}':                /* done */
  1151. X        tok_list_append(list, t);
  1152. X        return;
  1153. X    default:                /* other */
  1154. X        tok_list_append(list, t);
  1155. X        break;
  1156. X    }
  1157. X    }
  1158. X}
  1159. X
  1160. X/* tok_list_append - append data to list */
  1161. X
  1162. Xstatic void tok_list_append(h, t)
  1163. Xstruct token *h;
  1164. Xstruct token *t;
  1165. X{
  1166. X    if (h->head == 0) {
  1167. X    h->head = h->tail = t;
  1168. X    } else {
  1169. X    h->tail->next = t;
  1170. X    h->tail = t;
  1171. X    }
  1172. X}
  1173. END_OF_tok_class.c
  1174. if test 4091 -ne `wc -c <tok_class.c`; then
  1175.     echo shar: \"tok_class.c\" unpacked with wrong size!
  1176. fi
  1177. # end of overwriting check
  1178. fi
  1179. if test -f tok_io.c -a "${1}" != "-c" ; then 
  1180.   echo shar: Will not over-write existing file \"tok_io.c\"
  1181. else
  1182. echo shar: Extracting \"tok_io.c\" \(9985 characters\)
  1183. sed "s/^X//" >tok_io.c <<'END_OF_tok_io.c'
  1184. X/*++
  1185. X/* NAME
  1186. X/*    tok_io 3
  1187. X/* SUMMARY
  1188. X/*    token I/O
  1189. X/* PACKAGE
  1190. X/*    unproto
  1191. X/* SYNOPSIS
  1192. X/*    #include "token.h"
  1193. X/*
  1194. X/*    struct token *tok_get(skip_flag)
  1195. X/*    int skip_flag;
  1196. X/*
  1197. X/*    void tok_unget(t)
  1198. X/*    struct token *t;
  1199. X/*
  1200. X/*    void tok_flush(t)
  1201. X/*    struct token *t;
  1202. X/*
  1203. X/*    void tok_show(t)
  1204. X/*    struct token *t;
  1205. X/*
  1206. X/*    void put_str(s)
  1207. X/*    char *s;
  1208. X/*
  1209. X/*    void put_ch(c)
  1210. X/*    int c;
  1211. X/*
  1212. X/*    void show_line_control()
  1213. X/*
  1214. X/*    char curr_path[];
  1215. X/*    int curr_line;
  1216. X/* DESCRIPTION
  1217. X/*    These functions read from stdin and write to stdout. The
  1218. X/*    output functions maintain some memory so that two successive
  1219. X/*    words will always be separated by white space.
  1220. X/*
  1221. X/*    The input routines eliminate backslash-newline from the input.
  1222. X/*
  1223. X/*    tok_get() reads the next token from standard input. It returns
  1224. X/*    a null pointer when the end of input is reached. If the skip_flag
  1225. X/*    argument is nonzero, white space (except newline) will be skipped.
  1226. X/*
  1227. X/*    tok_unget() implements a limited amount of token push back.
  1228. X/*
  1229. X/*    tok_show() displays the contents of a (possibly composite) token
  1230. X/*    on the standard output.
  1231. X/*
  1232. X/*    tok_flush() displays the contents of a (possibly composite) token
  1233. X/*    on the standard output and makes it available for re-use.
  1234. X/*
  1235. X/*    put_str() writes a null-terminated string to standard output.
  1236. X/*
  1237. X/*    put_ch() writes one character to standard output.
  1238. X/*
  1239. X/*    show_line_control() displays the line number of the next line
  1240. X/*    to be written to standard output, in a format suitable for the C
  1241. X/*    compiler parser phase.
  1242. X/*
  1243. X/*    The curr_path[] and curr_line variables contain the input file name and 
  1244. X/*    line number of the most recently read token.
  1245. X/* BUGS
  1246. X/*    The tokenizer is just good enough for the unproto filter.
  1247. X/*    As a benefit, it is quite fast.
  1248. X/* AUTHOR(S)
  1249. X/*    Wietse Venema
  1250. X/*    Eindhoven University of Technology
  1251. X/*    Department of Mathematics and Computer Science
  1252. X/*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  1253. X/* LAST MODIFICATION
  1254. X/*    91/11/30 21:10:26
  1255. X/* VERSION/RELEASE
  1256. X/*    1.2
  1257. X/*--*/
  1258. X
  1259. Xstatic char io_sccsid[] = "@(#) tok_io.c 1.2 91/11/30 21:10:26";
  1260. X
  1261. X/* C library */
  1262. X
  1263. X#include <stdio.h>
  1264. X#include <ctype.h>
  1265. X
  1266. Xextern char *strchr();
  1267. Xextern char *malloc();
  1268. Xextern char *realloc();
  1269. Xextern char *strcpy();
  1270. X
  1271. X/* Application-specific stuff */
  1272. X
  1273. X#include "token.h"
  1274. X#include "vstring.h"
  1275. X#include "error.h"
  1276. X
  1277. X/* Stuff to keep track of original source file name and position */
  1278. X
  1279. Xchar    curr_path[BUFSIZ];        /* current file name */
  1280. Xint     curr_line = 0;            /* # of last read line */
  1281. X
  1282. X/* Forward declarations */
  1283. X
  1284. Xstatic void read_quoted();
  1285. Xstatic void read_comment();
  1286. X
  1287. X/* Buffered i/o stuff */
  1288. X
  1289. Xstatic struct vstring *buf = 0;        /* read-ahead buffer */
  1290. Xstatic char *bp = "";            /* buffer position */
  1291. X
  1292. X#ifdef DEBUG
  1293. X#define    INITBUF    1            /* small initial buffer size */
  1294. X#else
  1295. X#define    INITBUF BUFSIZ            /* reasonable initial buffer size */
  1296. X#endif
  1297. X
  1298. X#define    input()        (*bp ? *bp++ : next_line())
  1299. X#define    unput(c)    (*--bp = (c))
  1300. X
  1301. X#define    TOK_BUFSIZE    5        /* token push-back buffer size */
  1302. X
  1303. Xstatic struct token *tok_buf[TOK_BUFSIZE];
  1304. Xstatic int tok_bufpos = 0;
  1305. X
  1306. X/* Type of last token sent to output, for pretty printing */
  1307. X
  1308. Xstatic int last_tok = 0;
  1309. X
  1310. X/* Directives that should be ignored. */
  1311. X
  1312. X#ifdef IGNORE_DIRECTIVES
  1313. X
  1314. Xstatic char *ignore_directives[] = {
  1315. X    IGNORE_DIRECTIVES,
  1316. X    0,
  1317. X};
  1318. X
  1319. X#endif
  1320. X
  1321. X/* Modified string and ctype stuff. */
  1322. X
  1323. X#define    STREQUAL(x,y)    (*(x) == *(y) && strcmp((x),(y)) == 0)
  1324. X
  1325. X#define    ISALNUM(c)    (isalnum(c) || (c) == '_')
  1326. X#define    ISALPHA(c)    (isalpha(c) || (c) == '_')
  1327. X#define    ISSPACE(c)    (isspace(c) && c != '\n')
  1328. X#define    ISDOT(c)    (c == '.')
  1329. X
  1330. X/* Collect all characters that satisfy one condition */
  1331. X
  1332. X#define    COLLECT(v,c,cond) { \
  1333. X                register struct vstring *vs = v; \
  1334. X                register char *cp = vs->str; \
  1335. X                *cp++ = c; \
  1336. X                for (;;) { \
  1337. X                    if ((c = input()) == 0) { \
  1338. X                    break; \
  1339. X                    } else if (cond) { \
  1340. X                    if (VS_ADDCH(vs, cp, c) == 0) \
  1341. X                        error(1, "out of memory"); \
  1342. X                    } else { \
  1343. X                    unput(c); \
  1344. X                    break; \
  1345. X                    } \
  1346. X                } \
  1347. X                *cp = 0; \
  1348. X                }
  1349. X
  1350. X/* do_control - parse control line, uses tok_get() */
  1351. X
  1352. Xstatic int do_control()
  1353. X{
  1354. X    struct token *t1;
  1355. X    struct token *t2;
  1356. X    int     pass_thru = 1;        /* 0 = ignore, 1 = output */
  1357. X
  1358. X    (void) input();                /* skip the hash */
  1359. X
  1360. X    if (t1 = tok_get(NO_WSPACE)) {
  1361. X    switch (t1->tokno) {
  1362. X
  1363. X        /*
  1364. X         * In case of line number control, the remainder of the line has
  1365. X         * the format: linenumber "pathname".
  1366. X         */
  1367. X    case TOK_NUMBER:
  1368. X        if (t2 = tok_get(NO_WSPACE)) {
  1369. X        if (t2->tokno == '"') {
  1370. X            curr_line = atoi(t1->vstr->str) - 1;
  1371. X            strcpy(curr_path, t2->vstr->str);
  1372. X        }
  1373. X        tok_free(t2);
  1374. X        }
  1375. X        break;
  1376. X
  1377. X#ifdef IGNORE_DIRECTIVES
  1378. X    case TOK_WORD:
  1379. X        /* Optionally ignore other #directives, such as #pragma. */
  1380. X        {
  1381. X        char  **cpp;
  1382. X        char   *cp = t1->vstr->str;
  1383. X
  1384. X        for (cpp = ignore_directives; *cpp; cpp++) {
  1385. X            if (STREQUAL(cp, *cpp)) {
  1386. X            pass_thru = 0;
  1387. X            break;
  1388. X            }
  1389. X        }
  1390. X        }
  1391. X        break;
  1392. X#endif
  1393. X    }
  1394. X    tok_free(t1);
  1395. X    }
  1396. X    return (pass_thru);
  1397. X}
  1398. X
  1399. X/* next_line - read one logical line, handle #control */
  1400. X
  1401. Xstatic int next_line()
  1402. X{
  1403. X    register int c;
  1404. X    register char *cp;
  1405. X
  1406. X    /* Allocate buffer upon first entry */
  1407. X
  1408. X    if (buf == 0)
  1409. X    buf = vs_alloc(INITBUF);
  1410. X
  1411. X    for (;;) {
  1412. X    cp = buf->str;
  1413. X
  1414. X    /* Account for EOF and line continuations */
  1415. X
  1416. X    while ((c = getchar()) != EOF) {
  1417. X        if (VS_ADDCH(buf, cp, c) == 0)    /* store character */
  1418. X        error(1, "out of memory");
  1419. X        if (c == '\n') {            /* real end of line */
  1420. X        curr_line++;
  1421. X        break;
  1422. X        } else if (c == '\\') {
  1423. X        if ((c = getchar()) == EOF) {    /* XXX strip backslash-EOF */
  1424. X            break;
  1425. X        } else if (c == '\n') {        /* strip backslash-newline */
  1426. X            curr_line++;
  1427. X            put_ch('\n');        /* preserve line count */
  1428. X            cp--;            /* un-store backslash */
  1429. X        } else {
  1430. X            ungetc(c, stdin);        /* keep backslash-other */
  1431. X        }
  1432. X        }
  1433. X    }
  1434. X    *cp = 0;
  1435. X    bp = buf->str;
  1436. X
  1437. X    /* Account for EOF and #control */
  1438. X
  1439. X    switch (bp[0]) {
  1440. X    case 0:                    /* EOF */
  1441. X        return (0);
  1442. X    case '#':                /* control */
  1443. X        if (do_control())
  1444. X        fputs(buf->str, stdout);    /* pass through */
  1445. X        else
  1446. X        putchar('\n');            /* filter out */
  1447. X        break;
  1448. X    default:                /* non-control */
  1449. X        return (input());
  1450. X    }
  1451. X    }
  1452. X}
  1453. X
  1454. X/* tok_unget - push back one token */
  1455. X
  1456. Xvoid    tok_unget(t)
  1457. Xregister struct token *t;
  1458. X{
  1459. X    if (tok_bufpos >= TOK_BUFSIZE)
  1460. X    error(1, "too much pushback");
  1461. X    tok_buf[tok_bufpos++] = t;
  1462. X}
  1463. X
  1464. X/* tok_get - get next token */
  1465. X
  1466. Xstruct token *tok_get(skip_flag)
  1467. Xint     skip_flag;
  1468. X{
  1469. X    register struct token *t;
  1470. X    register int c;
  1471. X    int     d;
  1472. X
  1473. X    /* Use push-back token, if any. */
  1474. X
  1475. X    if (tok_bufpos) {
  1476. X    t = tok_buf[--tok_bufpos];
  1477. X    return (t);
  1478. X    }
  1479. X
  1480. X    /*
  1481. X     * Get one from the pool and fill it in. The loop is here in case we
  1482. X     * should skip white-space tokens, which happens in a minority of all
  1483. X     * cases.
  1484. X     */
  1485. X
  1486. X    t = tok_alloc();
  1487. X
  1488. X    for (;;) {
  1489. X    if ((c = input()) == 0) {
  1490. X        tok_free(t);
  1491. X        return (0);
  1492. X    } else if (!isascii(c)) {
  1493. X        t->vstr->str[0] = c;
  1494. X        t->vstr->str[1] = 0;
  1495. X        t->tokno = TOK_OTHER;
  1496. X        return (t);
  1497. X    } else if (c == '"' || c == '\'') {
  1498. X        read_quoted(t, c);
  1499. X        t->tokno = c;
  1500. X        return (t);
  1501. X    } else if (ISALPHA(c)) {
  1502. X        COLLECT(t->vstr, c, ISALNUM(c));
  1503. X        t->tokno = TOK_WORD;
  1504. X        return (t);
  1505. X    } else if (isdigit(c)) {
  1506. X        COLLECT(t->vstr, c, isdigit(c));
  1507. X        t->tokno = TOK_NUMBER;
  1508. X        return (t);
  1509. X    } else if (ISSPACE(c)) {
  1510. X        COLLECT(t->vstr, c, ISSPACE(c));
  1511. X        if (skip_flag)
  1512. X        continue;
  1513. X        t->tokno = TOK_WSPACE;
  1514. X        return (t);
  1515. X    } else if (ISDOT(c)) {
  1516. X        COLLECT(t->vstr, c, ISDOT(c));
  1517. X        t->tokno = TOK_OTHER;
  1518. X        return (t);
  1519. X    } else {
  1520. X        t->vstr->str[0] = c;
  1521. X        if (c == '/') {
  1522. X        if ((d = input()) == '*') {
  1523. X            t->vstr->str[1] = d;    /* comment */
  1524. X            read_comment(t->vstr);
  1525. X            if (skip_flag)
  1526. X            continue;
  1527. X            t->tokno = TOK_WSPACE;
  1528. X            return (t);
  1529. X        } else {
  1530. X            unput(d);
  1531. X        }
  1532. X        }
  1533. X        t->vstr->str[1] = 0;
  1534. X        t->tokno = c;
  1535. X        return (t);
  1536. X    }
  1537. X    }
  1538. X}
  1539. X
  1540. X/* read_qouted - read string or character literal */
  1541. X
  1542. Xstatic void read_quoted(t, ch)
  1543. Xregister struct token *t;
  1544. Xint     ch;
  1545. X{
  1546. X    register char *cp = t->vstr->str;
  1547. X    register int c;
  1548. X
  1549. X    *cp++ = ch;
  1550. X
  1551. X    while (c = input()) {
  1552. X    if (c == '\n') {            /* newline in string */
  1553. X        unput(c);
  1554. X        break;
  1555. X    }
  1556. X    if (VS_ADDCH(t->vstr, cp, c) == 0)    /* store character */
  1557. X        error(1, "out of memory");
  1558. X    if (c == ch)                /* end of string */
  1559. X        break;
  1560. X    if (c == '\\')                /* eat next character */
  1561. X        if ((c = input()) != 0 && VS_ADDCH(t->vstr, cp, c) == 0)
  1562. X        error(1, "out of memory");
  1563. X    }
  1564. X    *cp = 0;
  1565. X    return;
  1566. X}
  1567. X
  1568. X/* read_comment - stuff a whole comment into one huge token */
  1569. X
  1570. Xstatic void read_comment(vs)
  1571. Xregister struct vstring *vs;
  1572. X{
  1573. X    register char *cp = vs->str + 2;    /* skip slash star */
  1574. X    register int c;
  1575. X    register int d;
  1576. X
  1577. X    while (c = input()) {
  1578. X    if (VS_ADDCH(vs, cp, c) == 0)
  1579. X        error(1, "out of memory");
  1580. X    if (c == '*') {
  1581. X        if ((d = input()) == '/') {
  1582. X        if (VS_ADDCH(vs, cp, d) == 0)
  1583. X            error(1, "out of memory");
  1584. X        break;
  1585. X        } else {
  1586. X        unput(d);
  1587. X        }
  1588. X    }
  1589. X    }
  1590. X    *cp = 0;
  1591. X}
  1592. X
  1593. X/* put_str - output a string */
  1594. X
  1595. Xvoid    put_str(s)
  1596. Xchar   *s;
  1597. X{
  1598. X    fputs(s, stdout);
  1599. X    last_tok = s[0];                /* XXX */
  1600. X#ifdef DEBUG
  1601. X    fflush(stdout);
  1602. X#endif
  1603. X}
  1604. X
  1605. X/* put_ch - put character */
  1606. X
  1607. Xvoid    put_ch(c)
  1608. Xint     c;
  1609. X{
  1610. X    last_tok = putchar(c);
  1611. X#ifdef DEBUG
  1612. X    fflush(stdout);
  1613. X#endif
  1614. X}
  1615. X
  1616. X/* tok_show - output (possibly composite) token */
  1617. X
  1618. Xvoid    tok_show(t)
  1619. Xstruct token *t;
  1620. X{
  1621. X    register struct token *p;
  1622. X    register struct token *s;
  1623. X
  1624. X    switch (t->tokno) {
  1625. X    case TOK_LIST:
  1626. X    for (s = t->head; s; s = s->next) {
  1627. X        put_ch(s->tokno);            /* opening paren or ',' */
  1628. X        for (p = s->head; p; p = p->next)
  1629. X        tok_show(p);
  1630. X    }
  1631. X    put_ch(')');                /* closing paren */
  1632. X    break;
  1633. X    case TOK_WORD:
  1634. X    if (ISALPHA(last_tok))
  1635. X        putchar(' ');
  1636. X    /* FALLTRHOUGH */
  1637. X    default:
  1638. X    fputs(t->vstr->str, stdout);        /* token contents */
  1639. X    last_tok = t->vstr->str[0];
  1640. X#ifdef DEBUG
  1641. X    fflush(stdout);
  1642. X#endif
  1643. X    if (t->head)                /* trailing blanks */
  1644. X            for (p = t->head; p; p = p->next)
  1645. X                tok_show(p);
  1646. X    }
  1647. X}
  1648. END_OF_tok_io.c
  1649. if test 9985 -ne `wc -c <tok_io.c`; then
  1650.     echo shar: \"tok_io.c\" unpacked with wrong size!
  1651. fi
  1652. # end of overwriting check
  1653. fi
  1654. if test -f tok_pool.c -a "${1}" != "-c" ; then 
  1655.   echo shar: Will not over-write existing file \"tok_pool.c\"
  1656. else
  1657. echo shar: Extracting \"tok_pool.c\" \(2184 characters\)
  1658. sed "s/^X//" >tok_pool.c <<'END_OF_tok_pool.c'
  1659. X/*++
  1660. X/* NAME
  1661. X/*    tok_pool 3
  1662. X/* SUMMARY
  1663. X/*    maintain pool of unused token structures
  1664. X/* PACKAGE
  1665. X/*    unproto
  1666. X/* SYNOPSIS
  1667. X/*    #include "token.h"
  1668. X/*
  1669. X/*    struct token *tok_alloc()
  1670. X/*
  1671. X/*    void tok_free(t)
  1672. X/*    struct token *t;
  1673. X/* DESCRIPTION
  1674. X/*    tok_alloc() and tok_free() maintain a pool of unused token
  1675. X/*    structures.
  1676. X/*
  1677. X/*    tok_alloc() takes the first free token structure from the pool
  1678. X/*    or allocates a new one if the pool is empty.
  1679. X/*
  1680. X/*    tok_free() adds a (possibly composite) token structure to the pool.
  1681. X/* BUGS
  1682. X/*    The pool never shrinks.
  1683. X/* AUTHOR(S)
  1684. X/*    Wietse Venema
  1685. X/*    Eindhoven University of Technology
  1686. X/*    Department of Mathematics and Computer Science
  1687. X/*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  1688. X/* LAST MODIFICATION
  1689. X/*    91/09/01 23:08:36
  1690. X/* VERSION/RELEASE
  1691. X/*    1.1
  1692. X/*--*/
  1693. X
  1694. Xstatic char pool_sccsid[] = "@(#) tok_pool.c 1.1 91/09/01 23:08:36";
  1695. X
  1696. X/* C library */
  1697. X
  1698. Xextern char *malloc();
  1699. X
  1700. X/* Application-specific stuff */
  1701. X
  1702. X#include "token.h"
  1703. X#include "vstring.h"
  1704. X
  1705. Xextern void error();
  1706. X
  1707. X#define    TOKLEN    5            /* initial string buffer length */
  1708. X
  1709. Xstruct token *tok_pool = 0;        /* free token pool */
  1710. X
  1711. X/* tok_alloc - allocate token structure from pool or heap */
  1712. X
  1713. Xstruct token *tok_alloc()
  1714. X{
  1715. X    register struct token *t;
  1716. X
  1717. X    if (tok_pool) {                /* re-use an old one */
  1718. X    t = tok_pool;
  1719. X    tok_pool = t->next;
  1720. X    } else {                    /* create a new one */
  1721. X    if ((t = (struct token *) malloc(sizeof(struct token))) == 0
  1722. X        || (t->vstr = vs_alloc(TOKLEN)) == 0)
  1723. X        error(1, "out of memory");
  1724. X    }
  1725. X    t->next = t->head = t->tail = 0;
  1726. X#ifdef    DEBUG
  1727. X    strcpy(t->vstr->str, "BUSY");
  1728. X#endif
  1729. X    return (t);
  1730. X}
  1731. X
  1732. X/* tok_free - return (possibly composite) token to pool of free tokens */
  1733. X
  1734. Xvoid    tok_free(t)
  1735. Xregister struct token *t;
  1736. X{
  1737. X#ifdef DEBUG
  1738. X    /* Check if we are freeing free token */
  1739. X
  1740. X    register struct token *p;
  1741. X
  1742. X    for (p = tok_pool; p; p = p->next)
  1743. X    if (p == t)
  1744. X        error(1, "freeing free token");
  1745. X#endif
  1746. X
  1747. X    /* Free neighbours and subordinates first */
  1748. X
  1749. X    if (t->next)
  1750. X    tok_free(t->next);
  1751. X    if (t->head)
  1752. X    tok_free(t->head);
  1753. X
  1754. X    /* Free self */
  1755. X
  1756. X    t->next = tok_pool;
  1757. X    t->head = t->tail = 0;
  1758. X    tok_pool = t;
  1759. X#ifdef    DEBUG
  1760. X    strcpy(t->vstr->str, "FREE");
  1761. X#endif
  1762. X}
  1763. END_OF_tok_pool.c
  1764. if test 2184 -ne `wc -c <tok_pool.c`; then
  1765.     echo shar: \"tok_pool.c\" unpacked with wrong size!
  1766. fi
  1767. # end of overwriting check
  1768. fi
  1769. if test -f token.h -a "${1}" != "-c" ; then 
  1770.   echo shar: Will not over-write existing file \"token.h\"
  1771. else
  1772. echo shar: Extracting \"token.h\" \(1523 characters\)
  1773. sed "s/^X//" >token.h <<'END_OF_token.h'
  1774. X/* @(#) token.h 1.3 91/11/30 21:10:37 */
  1775. X
  1776. Xtypedef struct token {
  1777. X    int     tokno;            /* token value, see below */
  1778. X    int     len;            /* string or list length */
  1779. X    struct vstring *vstr;        /* token contents */
  1780. X    struct token *next;
  1781. X    struct token *head;
  1782. X    struct token *tail;
  1783. X};
  1784. X
  1785. X/* Special token values */
  1786. X
  1787. X#define    TOK_LIST    256        /* () delimited list */
  1788. X#define    TOK_WORD    257        /* keyword or identifier */
  1789. X#define    TOK_NUMBER    258        /* number */
  1790. X#define    TOK_WSPACE    259        /* white space except newline */
  1791. X#define    TOK_OTHER    260        /* other multi-char token */
  1792. X#define    TOK_CONTROL    261        /* flow control keyword */
  1793. X#define    TOK_COMPOSITE    262        /* struct or union */
  1794. X
  1795. X/* Input/output functions and macros */
  1796. X
  1797. Xextern struct token *tok_get();        /* read next single token */
  1798. Xextern void tok_show();            /* display (composite) token */
  1799. Xextern struct token *tok_class();    /* classify tokens */
  1800. Xextern void put_ch();            /* write character */
  1801. Xextern void put_str();            /* write string */
  1802. Xextern void tok_unget();        /* stuff token back into input */
  1803. X
  1804. X#define    tok_flush(t)    (tok_show(t), tok_free(t))
  1805. X
  1806. X/* tok_get() and tok_class() options */
  1807. X
  1808. X#define    DO_WSPACE    0        /* retain space, tab */
  1809. X#define    NO_WSPACE    1        /* skip space, tab */
  1810. X
  1811. X/* Memory management */
  1812. X
  1813. Xstruct token *tok_alloc();        /* allocate token storage */
  1814. Xextern void tok_free();            /* re-cycle storage */
  1815. X
  1816. X/* Context */
  1817. X
  1818. Xextern char curr_path[];        /* current path name */
  1819. Xextern int curr_line;            /* current line number */
  1820. X#define    show_line_control() printf("# %d %s\n", curr_line, curr_path);
  1821. END_OF_token.h
  1822. if test 1523 -ne `wc -c <token.h`; then
  1823.     echo shar: \"token.h\" unpacked with wrong size!
  1824. fi
  1825. # end of overwriting check
  1826. fi
  1827. if test -f unproto.1 -a "${1}" != "-c" ; then 
  1828.   echo shar: Will not over-write existing file \"unproto.1\"
  1829. else
  1830. echo shar: Extracting \"unproto.1\" \(2067 characters\)
  1831. sed "s/^X//" >unproto.1 <<'END_OF_unproto.1'
  1832. X.TH UNPROTO 1 
  1833. X.ad
  1834. X.fi
  1835. X.SH NAME
  1836. Xunproto
  1837. X\-
  1838. XANSI C to old C converter
  1839. X.SH PACKAGE
  1840. X.na
  1841. X.nf
  1842. Xunproto
  1843. X.SH SYNOPSIS
  1844. X.na
  1845. X.nf
  1846. X/lib/cpp ... | unproto
  1847. X
  1848. X/somewhere/cpp ...
  1849. X.SH DESCRIPTION
  1850. X.ad
  1851. X.fi
  1852. XThis document describes a filter that sits between the
  1853. XC preprocessor (usually \fI/lib/cpp\fP) and the next C compiler
  1854. Xpass. It rewrites ANSI-C style function headers, function type
  1855. Xdeclarations, function pointer types, and function pointer casts
  1856. Xto old style. Other ANSI-isms are passed on without modification
  1857. X(token pasting, pragmas, etcetera).
  1858. X
  1859. XFor maximal flexibility, the "cpp | unproto" pipeline can  be
  1860. Xpackaged as an executable shell script named "/somewhere/cpp".
  1861. XThis script should then be specified to the C compiler as a
  1862. Xnon-default preprocessor.
  1863. X
  1864. XThe overhead of shell script interpretation can be avoided by
  1865. Xhaving the unprototyper itself open the pipe to the preprocessor.
  1866. XIn that case, the source should be compiled with the PIPE_THROUGH_CPP
  1867. Xmacro defined (usually as "/lib/cpp"), and the resulting binary
  1868. Xshould be installed as "/somewhere/cpp".
  1869. X.SH SEE ALSO
  1870. X.na
  1871. X.nf
  1872. X.ad
  1873. X.fi
  1874. Xcc(1), how to specify a non-default C preprocessor.
  1875. X
  1876. XSome versions of the lint command are implemented as a shell
  1877. Xscript. It should require only minor modification for integration
  1878. Xwith the unprotoizer. Other versions of the lint command accept the same
  1879. Xcommand syntax as the C compiler for the specification of a non-default
  1880. Xpreprocessor. Some research may be needed.
  1881. X.SH DIAGNOSTICS
  1882. X.ad
  1883. X.fi
  1884. XThe progam will complain if it unexpectedly
  1885. Xreaches the end of input.
  1886. X.SH BUGS
  1887. X.ad
  1888. X.fi
  1889. XShould be run on preprocessed source only, i.e. after macro expansion.
  1890. X
  1891. XDeclarations of (whatever) are misunderstood and will result in
  1892. Xsyntax errors.
  1893. X
  1894. XDoes not generate explicit type casts for function argument
  1895. Xexpressions.
  1896. X.SH AUTHOR(S)
  1897. X.na
  1898. X.nf
  1899. XWietse Venema (wietse@wzv.win.tue.nl)
  1900. XEindhoven University of Technology
  1901. XDepartment of Mathematics and Computer Science
  1902. XDen Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  1903. X.SH LAST MODIFICATION
  1904. X.na
  1905. X.nf
  1906. X91/09/22 21:21:35
  1907. X.SH VERSION/RELEASE
  1908. X.na
  1909. X.nf
  1910. X1.2
  1911. END_OF_unproto.1
  1912. if test 2067 -ne `wc -c <unproto.1`; then
  1913.     echo shar: \"unproto.1\" unpacked with wrong size!
  1914. fi
  1915. # end of overwriting check
  1916. fi
  1917. if test -f varargs.c -a "${1}" != "-c" ; then 
  1918.   echo shar: Will not over-write existing file \"varargs.c\"
  1919. else
  1920. echo shar: Extracting \"varargs.c\" \(606 characters\)
  1921. sed "s/^X//" >varargs.c <<'END_OF_varargs.c'
  1922. X /*
  1923. X  * @(#) varargs.c 1.1 91/09/01 23:08:45
  1924. X  * 
  1925. X  * This program can be used to verify that the stdarg.h file is set up
  1926. X  * correctly for your system. If it works, it should print one line with the
  1927. X  * text "stdarg.h works".
  1928. X  */
  1929. X
  1930. X#include <stdio.h>
  1931. X#include "stdarg.h"
  1932. X
  1933. Xmain(int argc, char *argv[])
  1934. X{
  1935. X    varargs_test("%s %s\n", "stdarg.h", "works");
  1936. X}
  1937. X
  1938. Xvarargs_test(char *fmt, ...)
  1939. X{
  1940. X    va_list ap;
  1941. X
  1942. X    va_start(ap, fmt);
  1943. X    while (*fmt) {
  1944. X    if (strncmp("%s", fmt, 2) == 0) {
  1945. X        fputs(va_arg(ap, char *), stdout);
  1946. X        fmt += 2;
  1947. X    } else {
  1948. X        putchar(*fmt);
  1949. X        fmt++;
  1950. X    }
  1951. X    }
  1952. X    va_end(ap);
  1953. X}
  1954. END_OF_varargs.c
  1955. if test 606 -ne `wc -c <varargs.c`; then
  1956.     echo shar: \"varargs.c\" unpacked with wrong size!
  1957. fi
  1958. # end of overwriting check
  1959. fi
  1960. if test -f vstring.c -a "${1}" != "-c" ; then 
  1961.   echo shar: Will not over-write existing file \"vstring.c\"
  1962. else
  1963. echo shar: Extracting \"vstring.c\" \(2328 characters\)
  1964. sed "s/^X//" >vstring.c <<'END_OF_vstring.c'
  1965. X/*++
  1966. X/* NAME
  1967. X/*    vs_alloc(), VS_ADDCH()
  1968. X/* SUMMARY
  1969. X/*    auto-resizing string library
  1970. X/* PACKAGE
  1971. X/*    vstring
  1972. X/* SYNOPSIS
  1973. X/*    #include "vstring.h"
  1974. X/*
  1975. X/*    struct vstring *vs_alloc(len)
  1976. X/*    int len;
  1977. X/*
  1978. X/*    int VS_ADDCH(vs, wp, ch)
  1979. X/*    struct vstring *vs;
  1980. X/*    char *wp;
  1981. X/*    int ch;
  1982. X/* DESCRIPTION
  1983. X/*    These functions and macros implement a small library for
  1984. X/*    arbitrary-length strings that grow automatically when
  1985. X/*    they fill up. The allocation strategy is such that there
  1986. X/*    will always be place for the terminating null character.
  1987. X/*
  1988. X/*    vs_alloc() allocates storage for a variable-length string.
  1989. X/*
  1990. X/*    VS_ADDCH() adds a character to a variable-length string
  1991. X/*    and automagically extends the string if fills up.
  1992. X/*    \fIvs\fP is a pointer to a vstring structure; \fIwp\fP
  1993. X/*    the current write position in the corresponding character
  1994. X/*    array; \fIch\fP the character value to be written.
  1995. X/*    Note that VS_ADDCH() is a macro that evaluates some
  1996. X/*    arguments more than once.
  1997. X/* DIAGNOSTICS
  1998. X/*    VS_ADDCH() returns zero if it was unable to dynamically
  1999. X/*    resize a string.
  2000. X/*
  2001. X/*    vs_alloc() returns a null pointer in case of problems.
  2002. X/* BUGS
  2003. X/*    Auto-resizing may change the address of the string data in
  2004. X/*    a vstring structure. Beware of dangling pointers.
  2005. X/* AUTHOR(S)
  2006. X/*    Wietse Venema
  2007. X/*    Eindhoven University of Technology
  2008. X/*    Department of Mathematics and Computer Science
  2009. X/*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  2010. X/* LAST MODIFICATION
  2011. X/*    91/09/22 21:21:38
  2012. X/* VERSION/RELEASE
  2013. X/*    1.2
  2014. X/*--*/
  2015. X
  2016. Xstatic char vstring_sccsid[] = "@(#) vstring.c 1.2 91/09/22 21:21:38";
  2017. X
  2018. X/* C library */
  2019. X
  2020. Xextern char *malloc();
  2021. Xextern char *realloc();
  2022. X
  2023. X/* Application-specific stuff */
  2024. X
  2025. X#include "vstring.h"
  2026. X
  2027. X/* vs_alloc - initial string allocation */
  2028. X
  2029. Xstruct vstring *vs_alloc(len)
  2030. Xint     len;
  2031. X{
  2032. X    register struct vstring *vp;
  2033. X
  2034. X    if (len < 1 
  2035. X    || (vp = (struct vstring *) malloc(sizeof(struct vstring))) == 0
  2036. X    || (vp->str = malloc(len)) == 0)
  2037. X    return (0);
  2038. X    vp->last = vp->str + len - 1;
  2039. X    return (vp);
  2040. X}
  2041. X
  2042. X/* vs_realloc - extend string, update write pointer */
  2043. X
  2044. Xchar   *vs_realloc(vp, cp)
  2045. Xregister struct vstring *vp;
  2046. Xchar   *cp;
  2047. X{
  2048. X    int     where = cp - vp->str;
  2049. X    int     len = vp->last - vp->str + 1;
  2050. X
  2051. X    if ((vp->str = realloc(vp->str, len *= 2)) == 0)
  2052. X    return (0);
  2053. X    vp->last = vp->str + len - 1;
  2054. X    return (vp->str + where);
  2055. X}
  2056. END_OF_vstring.c
  2057. if test 2328 -ne `wc -c <vstring.c`; then
  2058.     echo shar: \"vstring.c\" unpacked with wrong size!
  2059. fi
  2060. # end of overwriting check
  2061. fi
  2062. if test -f vstring.h -a "${1}" != "-c" ; then 
  2063.   echo shar: Will not over-write existing file \"vstring.h\"
  2064. else
  2065. echo shar: Extracting \"vstring.h\" \(410 characters\)
  2066. sed "s/^X//" >vstring.h <<'END_OF_vstring.h'
  2067. X/* @(#) vstring.h 1.1 91/09/01 23:08:42 */
  2068. X
  2069. Xstruct vstring {
  2070. X    char   *str;            /* string value */
  2071. X    char   *last;            /* last position */
  2072. X};
  2073. X
  2074. Xextern struct vstring *vs_alloc();    /* initial allocation */
  2075. Xextern char *vs_realloc();        /* string extension */
  2076. X
  2077. X/* macro to add one character to auto-resized string */
  2078. X
  2079. X#define    VS_ADDCH(vs,wp,c) \
  2080. X    ((wp < (vs)->last || (wp = vs_realloc(vs,wp))) ? (*wp++ = c) : 0)
  2081. END_OF_vstring.h
  2082. if test 410 -ne `wc -c <vstring.h`; then
  2083.     echo shar: \"vstring.h\" unpacked with wrong size!
  2084. fi
  2085. # end of overwriting check
  2086. fi
  2087. echo shar: End of archive 1 \(of 2\).
  2088. cp /dev/null ark1isdone
  2089. MISSING=""
  2090. for I in 1 2 ; do
  2091.     if test ! -f ark${I}isdone ; then
  2092.     MISSING="${MISSING} ${I}"
  2093.     fi
  2094. done
  2095. if test "${MISSING}" = "" ; then
  2096.     echo You have unpacked both archives.
  2097.     rm -f ark[1-9]isdone
  2098. else
  2099.     echo You still need to unpack the following archives:
  2100.     echo "        " ${MISSING}
  2101. fi
  2102. ##  End of shell archive.
  2103. exit 0
  2104.  
  2105. exit 0 # Just in case...
  2106. -- 
  2107. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2108. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2109. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2110. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2111.